// let a :number = 123

// let b :string = 'aaaa'

// let c :any = ['afwafafwad']

// let d :number[] = [1]

// let r :never
// let e :number&string

// let aa :void 

// let bb :unknown


// 泛型:泛型允许在定义函数、接口时将类型参数化，而不必预先指定具体的类型。可以理解为类型的形参，在调用函数或者接口时再传入具体的类型。
// const a = ref(0) //{ value :0 }

// function ref<T> (params: T)  {
//     return {
//         value :params
//     }
// }


// const num = ref<number>(0) //
// const str = ref('')
// const arr = ref([1,2,3,4,5])
// const arr1 = ref<string[]>([])


// interface Person<T ,U ,K> {
//     name:string,
//     age:number,
//     sex:T,
//     hobby:U,
//     marry:K
// }

// const xm: Person<'男' | '女',boolean,boolean> = {
//     name:'xm',
//     age:22,
//     sex:'男',
//     hobby:true,
//     marry:false
// }


// function getUser() {
//     return { id: 1, name: "Alice" };
//   }
  
//   // ReturnType 获取函数的返回类型
//   type UserReturnType = ReturnType<typeof getUser>;


// function format<T>(arr:T[]) {
//     return arr.map(v => {
//         return {
//             value :v
//         }
//     })
// }


// const arr1 = format([1,2,3,4,5])
// const arr2 = format(['1','2','3'])
// const arr3 = format([{name:1,age:22}])


// type DeepArr<T> = T | DeepArr<T>[]
// const arr: DeepArr<number> = [1,[2,3],4,[5,6],[7,8,9]]

// function flat<T>(arr: DeepArr<T>[]): T[] {
//     return arr.reduce((prev: T[],val) => {
//         return prev.concat(Array.isArray(val) ? flat(val) : val)
//     },[] as T[])
// }
// const arr1 = flat(arr)
// console.log(arr1)

// function getVal<T, K extends keyof T>(obj: T, key: K): T[K] {
//     return obj[key]
//   }

//   const obj = {
//     name: '小明',
//     age: 33,
//     sex: '男'
//   }
// const a = getVal(obj , 'age')



// type Obj1 = typeof obj
// type Obj1Keys = keyof typeof obj

function getUser() {
    return { id: 1, name: "Alice" };
  }
  
  // ReturnType 获取函数的返回类型
  type UserReturnType = ReturnType<typeof getUser>;